Crate amplify

Source
Expand description

Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros.

Minimum supported rust compiler version (MSRV): 1.46 (stable channel)

Re-exports§

Modules§

  • confinement
    Confinement puts a constraint on the number of elements within a collection.
  • flags
    Types for building flag-based APIs and functionality
  • hex
    Hex encoding and decoding
  • num
    Custom-sized numeric types
  • strategy
    This is a trick for rust compiler helping to distinguish types implementing mutually-exclusive traits (required until negative trait impls will be there) Implemented after concept by Martin Habovštiak martin.habovstiak@gmail.com

Macros§

Structs§

  • Array
    Wrapper type for all fixed arrays implementing many important traits, so types based on it can simply derive their implementations.
  • ConfinedIo
    Errors with io::ErrorKind::UnexpectedEof on io::Read and io::Write operations if the LIM is reached.
  • FlagRef
    Keeps a reference to a specific feature flag within FlagVec vector
  • FlagVec
    Bit flag vector. Can hold up to 2^16-1 flags and guaranteed to have length up to 255 bytes.
  • FromSliceError
    Error when slice size mismatches array length.
  • IoError
    Copyable & cloneable I/O error type represented by the error kind function.
  • WriteCounter
    A simple way to count bytes written through io::Write.

Traits§

  • AsAny
    Trait AsAny allows simple conversion of any type into a generic “thick” pointer &dyn Any (see Any), that can be later converted back to the original type with a graceful failing for all other conversions. For simple conversions it is recommended to use #[derive(AsAny)] macro from amplify_derive crate (see amplify_derive::AsAny).
  • ByteArray
    Trait which does a blanket implementation for all types wrapping Arrays
  • Dumb
    Used as an alternative to default for test and prototyping purposes, when a type can’t have a default value, but you need to generate some dumb data.
  • JoinSplit
    Trait for splittable streams and other types, which can be separated into some two types (JoinSplit::A, JoinSplit::B), like a reader and writer streams.
  • RawArrayDeprecated
    Trait which does a blanket implementation for all types wrapping Arrays
  • Wrapper
    Trait defining wrapped types (“newtypes” in rust terminology). Wrapped types are used for allowing implemeting foreign traits to foreign types: https://doc.rust-lang.org/stable/rust-by-example/generics/new_types.html
  • WrapperMut
    Trait allowing mutable reference borrowing for the wrapped inner type.

Type Aliases§

  • Bytes
    Wrapper type for all array-based bytes implementing many important traits, so types based on it can simply derive their implementations.
  • Bytes4
    Wrapper type for all array-based 32-bit types implementing many important traits, so types based on it can simply derive their implementations.
  • Bytes16
    Wrapper type for all array-based 128-bit types implementing many important traits, so types based on it can simply derive their implementations.
  • Bytes20
    Wrapper type for all array-based 160-bit types implementing many important traits, so types based on it can simply derive their implementations.
  • Bytes32
    Wrapper type for all array-based 256-bit types implementing many important traits, so types based on it can simply derive their implementations.
  • Bytes64
    Wrapper type for all array-based 512-bit types implementing many important traits, so types based on it can simply derive their implementations.
  • Bytes32StrRev
    Wrapper type for all array-based 256-bit types implementing many important traits, so types based on it can simply derive their implementations.
  • FlagNo
    A single feature flag, represented by it’s number inside feature vector

Derive Macros§

  • AsAny
    Trait amplify::AsAny allows simple conversion of any type into a generic “thick” pointer &dyn Any (see [::core::any::Any]), that can be later converted back to the original type with a graceful failing for all other conversions. AsAny derive macro allows to implement this trait for arbitrary time without much hussle:
  • Display
    Usage
  • Error
    Error derive macro works to the full extend only when other derive macros are used. With #[derive(Display)] and [display(doc_comments)] it uses doc comments for generating error descriptions; with #[derive(From)] it may automatically implement transofrations from other error types.
  • From
    Implements From trait for the whole entity and/or its separate fields. Works well with #[derive(Error)] and, in many cases may require [Default] implementation (for details, pls see Examples below)
  • Getters
    Derives getter methods for structures. The return type and naming of the methods depends on the provided attribute arguments.
  • Wrapper
    Creates rust new type wrapping existing type. Can be used in structures containing multiple named or unnamed fields; in this case the field you’d like to wrap should be marked with #[wrap] attribute; otherwise the first field is assumed to be the wrapped one.
  • WrapperMut
    Derives WrapperMut and allows deriving other traits accessing the wrapped type which require mutable access to the inner type. Requires that the type already implements amplify::Wrapper.